package com.wmh.baseservice.skd.service.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wmh.baseservice.common.service.TokenService;
import com.wmh.baseservice.common.utils.returnbody.ReturnBody;
import com.wmh.baseservice.skd.pojo.SkdGoodsInfo;
import com.wmh.baseservice.skd.pojo.SkdGoodsSpec;
import com.wmh.baseservice.skd.pojo.vo.AddGoodsReqVO;
import com.wmh.baseservice.skd.service.SkdGoodsInfoService;
import com.wmh.baseservice.skd.mapper.SkdGoodsInfoMapper;
import com.wmh.baseservice.skd.service.SkdGoodsSpecService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
* @author CH
* @description 针对表【skd_goods_info(平台商品表)】的数据库操作Service实现
* @createDate 2023-12-24 14:37:07
*/
@Service
@Slf4j
public class SkdGoodsInfoServiceImpl extends ServiceImpl<SkdGoodsInfoMapper, SkdGoodsInfo>
    implements SkdGoodsInfoService{

    @Resource
    private TokenService tokenService;
    @Resource
    private SkdGoodsInfoMapper skdGoodsInfoMapper;
    @Resource
    private SkdGoodsSpecService skdGoodsSpecService;

    /**
     * 统计指定用户上下架的商品
     * @param userId 用户id
     * @return 返回上下架的商品数量
     */
    @Override
    public Map<Integer, Integer> countGoodsOffShelvesByUserId(Long userId) {
        QueryWrapper<SkdGoodsInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId)
                .in("off_shelves", 0, 1);

        Map<Integer, Integer> result = new HashMap<>();
        result.put(0, this.count(queryWrapper.clone().eq("off_shelves", 0)));
        result.put(1, this.count(queryWrapper.clone().eq("off_shelves", 1)));

        return result;
    }

    @Override
    @Transactional
    public String addGoods(AddGoodsReqVO reqVO) {
        Long usId;
        try {
            // 根据token获取用户id
            usId = tokenService.getUserIdFromToken();
        } catch (IllegalStateException e) {
            log.error(e.getMessage());
            return ReturnBody.error("token异常!");
        }

        log.info("商品数据: " + reqVO);
        // 如果商品没有规格,则入参必须有单价
        if (Objects.isNull(reqVO.getPrice()) && StrUtil.isBlank(reqVO.getGoodsSpec())) {
            return ReturnBody.error("未提交商品单价!");
        }
        // 如果商品有规格,则校验参数是否为有效格式
        if (StrUtil.isNotBlank(reqVO.getGoodsSpec()) && !isValidGoodsSpec(reqVO.getGoodsSpec())) {
            return ReturnBody.error("商品规格格式有误!");
        }


        SkdGoodsInfo skdGoodsInfo = new SkdGoodsInfo();
        skdGoodsInfo.setUserId(usId)
                .setName(reqVO.getName())
                .setDescription(reqVO.getDescription())
                .setImgUrl(reqVO.getImgUrl())
                .setVideoUrl(reqVO.getVideoUrl())
                .setPrice(StrUtil.isBlank(reqVO.getGoodsSpec()) ? reqVO.getPrice() : new BigDecimal(-1))
                .setCrossedPrice(reqVO.getCrossedPrice())
                .setGoodsNo(reqVO.getGoodsNo())
                .setLabels(
                        Objects.isNull(reqVO.getLabels()) ? null : reqVO.getLabels().stream() // List<String> 转换为逗号分隔的字符串
                        .map(String::valueOf)
                        .collect(Collectors.joining(","))
                )
                .setCategoryId(reqVO.getCategoryId())
                .setHasSpec(StrUtil.isBlank(reqVO.getGoodsSpec()) ? -1 : 1);

        skdGoodsInfoMapper.insert(skdGoodsInfo);
        log.info("新增商品主键id为" + skdGoodsInfo.getId());
        if (StrUtil.isNotBlank(reqVO.getGoodsSpec())) {
            try {
                ObjectMapper mapper = new ObjectMapper();
                List<SkdGoodsSpec> skdGoodsSpec = mapper.readValue(reqVO.getGoodsSpec(), new TypeReference<List<SkdGoodsSpec>>() {});
                skdGoodsSpec.forEach(spec -> spec.setGoodsId(skdGoodsInfo.getId()));
                skdGoodsSpecService.saveBatch(skdGoodsSpec);
            } catch (JsonProcessingException e) {
                log.error("解析异常: {}", e.getMessage());
                return ReturnBody.error("请检查商品规格参数格式是否正确");
            }
        }
        return "添加成功";
    }

    /**
     * 修改商品规格
     * @param goodsId 商品id
     * @param jsonData 修改商品规格
     * @return 返回是否修改成功信息
     */
    @Override
    @Transactional
    public String modifyGoodsSpec(Long userId, Long goodsId, String jsonData) {
        log.info("goodsId: " + goodsId);
        log.info("jsonData: " + jsonData);
//        try {
//            ObjectMapper mapper = new ObjectMapper();
//            List<SkdGoodsSpec> newSpecs = mapper.readValue(jsonData, new TypeReference<List<SkdGoodsSpec>>() {
//            });
//
//            // 获取现有的规格
//            List<SkdGoodsSpec> existingSpecs = skdGoodsSpecService.getGoodsSpecListByGoodsId(goodsId);
//
//            log.info("商品对应商品规格: " + existingSpecs);
//
//            // 处理规格更新和添加
//            newSpecs.forEach(newSpec -> {
//                Optional<SkdGoodsSpec> existingSpec = existingSpecs.stream()
//                        .filter(es -> es.getId().equals(newSpec.getId()))
//                        .findFirst();
//                if (existingSpec.isPresent()) {
//                    // 更新现有规格
//                    log.info("更新现有规格");
//                    skdGoodsSpecService.saveOrUpdate(newSpec);
//                } else {
//                    // 添加新规格
//                    log.info("添加新规格");
//                    newSpec.setGoodsId(goodsId);
//                    skdGoodsSpecService.save(newSpec);
//                }
//            });
//
//            // 删除不再需要的规格
//            existingSpecs.forEach(existingSpec -> {
//                if (newSpecs.stream().noneMatch(newSpec -> newSpec.getId().equals(existingSpec.getId()))) {
//                    log.info("删除不再需要的规格");
//                    skdGoodsSpecService.removeById(existingSpec.getId());
//                }
//            });
//
//            // TODO 下架或删除用户购物车中修改前的商品
//            // 如果修改的内容只是商品规格价格, 则下架用户购物车内对应商品
//            if (!Objects.isNull(spec.getPrice())) {
//
//            }
//            // 如果修改的内容是商品规格, 则逻辑删除用户购物车内对应的商品
//
//        } catch (JsonProcessingException e) {
//            log.error("解析异常: {}", e.getMessage());
//            return ReturnBody.error("请检查商品规格参数格式是否正确");
//        }

//        try {
//            List<SkdGoodsSpec> skdGoodsSpecList = mapJsonToSkdGoodsSpecList(jsonData);
//
//            // 删除原有商品规格
//            boolean b = skdGoodsSpecService.deleteByGoodsId(goodsId);
//            if (!b) { ReturnBody.error("修改失败!"); }
//
//            for (SkdGoodsSpec spec : skdGoodsSpecList) {
//                log.info("spec: " + spec);
//                if (Objects.isNull(spec.getDescription()) || Objects.isNull(spec.getPrice())) {
//                    ReturnBody.error("商品规格缺少描述或价格参数, 请完善后重试!");
//                }
//                spec.setGoodsId(goodsId);
//                skdGoodsSpecService.save(spec);
//                // TODO 下架或删除用户购物车中修改前的商品
//                // 如果修改的内容只是商品规格价格, 则下架用户购物车内对应商品
//                if (!Objects.isNull(spec.getPrice())) {
//
//                }
//                // 如果修改的内容是商品规格, 则逻辑删除用户购物车内对应的商品
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            return ReturnBody.error("修改失败! " + e.getMessage());
//        }
//
        return ReturnBody.success("修改成功!");
    }

    /**
     * 根据商品id获取商品图片url
     * @param goodsId 商品id
     * @return 返回首张图片地址
     */
    @Override
    public String getGoodsImageUrlById(Long goodsId) {
        String res = skdGoodsInfoMapper.getGoodsImageUrlById(goodsId);
        // 使用 FastJSON 解析 JSON 字符串
        List<String> imageUrlList = JSON.parseArray(res, String.class);
        return imageUrlList.get(0);
    }

    /**
     * 根据商品id获取商品价格
     * @param goodsId 商品id
     * @return 返回商品价格
     */
    @Override
    public BigDecimal getGoodsPriceById(Long goodsId) {
        return skdGoodsInfoMapper.getGoodsPriceById(goodsId);
    }

    private List<SkdGoodsSpec> mapJsonToSkdGoodsSpecList(String jsonData) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode = objectMapper.readTree(jsonData);

        List<SkdGoodsSpec> skdGoodsSpecList = new ArrayList<>();

        for (JsonNode node : jsonNode) {
            SkdGoodsSpec skdGoodsSpec = mapJsonToSkdGoodsSpec(node);
            skdGoodsSpecList.add(skdGoodsSpec);
        }

        return skdGoodsSpecList;
    }

    private SkdGoodsSpec mapJsonToSkdGoodsSpec(JsonNode jsonNode) throws Exception {
        SkdGoodsSpec skdGoodsSpec = new SkdGoodsSpec();

        if (jsonNode.has("description")) {
            skdGoodsSpec.setDescription(jsonNode.get("description").asText());
        } else {
            throw new Exception("description 为必填字段");
        }

        if (jsonNode.has("imgUrl")) {
            skdGoodsSpec.setImgUrl(jsonNode.get("imgUrl").asText());
        }

        if (jsonNode.has("price")) {
            skdGoodsSpec.setPrice(new BigDecimal(jsonNode.get("price").asText()));
        } else {
            throw new Exception("price 为必填字段");
        }

        if (jsonNode.has("inventory")) {
            skdGoodsSpec.setInventory(jsonNode.get("inventory").asInt());
        }

        return skdGoodsSpec;
    }

    /**
     * 判断是否为有效商品规格格式
     * @param jsonString json格式字符串
     * @return 返回是否有效
     */
    @Override
    public boolean isValidGoodsSpec(String jsonString) {
        // 使用 Jackson 解析 JSON 字符串
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            JsonNode jsonArray = objectMapper.readTree(jsonString);

            // 验证是否为 JSON 数组
            if (jsonArray.isArray()) {
                // 遍历数组中的每个元素进行验证
                for (JsonNode jsonNode : jsonArray) {
                    // 验证是否包含必要字段
                    if (jsonNode.has("description") && jsonNode.has("imgUrl") && jsonNode.has("price") && jsonNode.has("inventory")) {
                        // 验证 "price" 和 "inventory" 的值是否为数值
                        if (jsonNode.get("price").isNumber() && jsonNode.get("inventory").isNumber()) {
                            continue;
                        } else {
                            return false;
                        }
                    } else {
                        return false;
                    }
                }
                // 全部元素验证通过，返回true
                return true;
            } else {
                // 不是 JSON 数组，返回false
                return false;
            }
        } catch (Exception e) {
            // 解析异常，说明格式有误，返回false
            return false;
        }
    }
}




